YES 3.064 H-Termination proof of /home/matraf/haskell/eval_FullyBlown_Fast/List.hs
H-Termination of the given Haskell-Program with start terms could successfully be proven:



HASKELL
  ↳ LR

mainModule List
  ((elemIndices :: Eq a => Maybe a  ->  [Maybe a ->  [Int]) :: Eq a => Maybe a  ->  [Maybe a ->  [Int])

module List where
  import qualified Maybe
import qualified Prelude

  elemIndices :: Eq a => a  ->  [a ->  [Int]
elemIndices x findIndices (== x)

  findIndices :: (a  ->  Bool ->  [a ->  [Int]
findIndices p xs concatMap (\vv1 ->
case vv1 of
  (x,i)->  if p x then i : [] else []
  _-> []
) (zip xs (enumFrom 0))


module Maybe where
  import qualified List
import qualified Prelude



Lambda Reductions:
The following Lambda expression
\vv1
case vv1 of
 (x,i) → if p x then i : [] else []
 _ → []

is transformed to
findIndices0 p vv1 = 
case vv1 of
 (x,i) → if p x then i : [] else []
 _ → []

The following Lambda expression
\ab→(a,b)

is transformed to
zip0 a b = (a,b)



↳ HASKELL
  ↳ LR
HASKELL
      ↳ CR

mainModule List
  ((elemIndices :: Eq a => Maybe a  ->  [Maybe a ->  [Int]) :: Eq a => Maybe a  ->  [Maybe a ->  [Int])

module List where
  import qualified Maybe
import qualified Prelude

  elemIndices :: Eq a => a  ->  [a ->  [Int]
elemIndices x findIndices (== x)

  findIndices :: (a  ->  Bool ->  [a ->  [Int]
findIndices p xs concatMap (findIndices0 p) (zip xs (enumFrom 0))

  
findIndices0 p vv1 
case vv1 of
  (x,i)->  if p x then i : [] else []
  _-> []


module Maybe where
  import qualified List
import qualified Prelude



Case Reductions:
The following Case expression
case vv1 of
 (x,i) → if p x then i : [] else []
 _ → []

is transformed to
findIndices00 p (x,i) = if p x then i : [] else []
findIndices00 p _ = []



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
HASKELL
          ↳ IFR

mainModule List
  ((elemIndices :: Eq a => Maybe a  ->  [Maybe a ->  [Int]) :: Eq a => Maybe a  ->  [Maybe a ->  [Int])

module List where
  import qualified Maybe
import qualified Prelude

  elemIndices :: Eq a => a  ->  [a ->  [Int]
elemIndices x findIndices (== x)

  findIndices :: (a  ->  Bool ->  [a ->  [Int]
findIndices p xs concatMap (findIndices0 p) (zip xs (enumFrom 0))

  
findIndices0 p vv1 findIndices00 p vv1

  
findIndices00 p (x,i if p x then i : [] else []
findIndices00 p _ []


module Maybe where
  import qualified List
import qualified Prelude



If Reductions:
The following If expression
if p x then i : [] else []

is transformed to
findIndices000 i True = i : []
findIndices000 i False = []



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
HASKELL
              ↳ BR

mainModule List
  ((elemIndices :: Eq a => Maybe a  ->  [Maybe a ->  [Int]) :: Eq a => Maybe a  ->  [Maybe a ->  [Int])

module List where
  import qualified Maybe
import qualified Prelude

  elemIndices :: Eq a => a  ->  [a ->  [Int]
elemIndices x findIndices (== x)

  findIndices :: (a  ->  Bool ->  [a ->  [Int]
findIndices p xs concatMap (findIndices0 p) (zip xs (enumFrom 0))

  
findIndices0 p vv1 findIndices00 p vv1

  
findIndices00 p (x,ifindIndices000 i (p x)
findIndices00 p _ []

  
findIndices000 i True i : []
findIndices000 i False []


module Maybe where
  import qualified List
import qualified Prelude



Replaced joker patterns by fresh variables and removed binding patterns.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
HASKELL
                  ↳ COR

mainModule List
  ((elemIndices :: Eq a => Maybe a  ->  [Maybe a ->  [Int]) :: Eq a => Maybe a  ->  [Maybe a ->  [Int])

module List where
  import qualified Maybe
import qualified Prelude

  elemIndices :: Eq a => a  ->  [a ->  [Int]
elemIndices x findIndices (== x)

  findIndices :: (a  ->  Bool ->  [a ->  [Int]
findIndices p xs concatMap (findIndices0 p) (zip xs (enumFrom 0))

  
findIndices0 p vv1 findIndices00 p vv1

  
findIndices00 p (x,ifindIndices000 i (p x)
findIndices00 p vw []

  
findIndices000 i True i : []
findIndices000 i False []


module Maybe where
  import qualified List
import qualified Prelude



Cond Reductions:
The following Function with conditions
undefined 
 | False
 = undefined

is transformed to
undefined  = undefined1

undefined0 True = undefined

undefined1  = undefined0 False



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
HASKELL
                      ↳ NumRed

mainModule List
  ((elemIndices :: Eq a => Maybe a  ->  [Maybe a ->  [Int]) :: Eq a => Maybe a  ->  [Maybe a ->  [Int])

module List where
  import qualified Maybe
import qualified Prelude

  elemIndices :: Eq a => a  ->  [a ->  [Int]
elemIndices x findIndices (== x)

  findIndices :: (a  ->  Bool ->  [a ->  [Int]
findIndices p xs concatMap (findIndices0 p) (zip xs (enumFrom 0))

  
findIndices0 p vv1 findIndices00 p vv1

  
findIndices00 p (x,ifindIndices000 i (p x)
findIndices00 p vw []

  
findIndices000 i True i : []
findIndices000 i False []


module Maybe where
  import qualified List
import qualified Prelude



Num Reduction: All numbers are transformed to thier corresponding representation with Pos, Neg, Succ and Zero.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ NumRed
HASKELL
                          ↳ Narrow

mainModule List
  (elemIndices :: Eq a => Maybe a  ->  [Maybe a ->  [Int])

module List where
  import qualified Maybe
import qualified Prelude

  elemIndices :: Eq a => a  ->  [a ->  [Int]
elemIndices x findIndices (== x)

  findIndices :: (a  ->  Bool ->  [a ->  [Int]
findIndices p xs concatMap (findIndices0 p) (zip xs (enumFrom (Pos Zero)))

  
findIndices0 p vv1 findIndices00 p vv1

  
findIndices00 p (x,ifindIndices000 i (p x)
findIndices00 p vw []

  
findIndices000 i True i : []
findIndices000 i False []


module Maybe where
  import qualified List
import qualified Prelude



Haskell To QDPs


↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
QDP
                                ↳ QDPSizeChangeProof
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primPlusNat(Succ(yu6600), Succ(yu4001000)) → new_primPlusNat(yu6600, yu4001000)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
QDP
                                ↳ QDPSizeChangeProof
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primMulNat(Succ(yu30100), Succ(yu400100)) → new_primMulNat(yu30100, Succ(yu400100))

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
QDP
                                ↳ QDPSizeChangeProof
                              ↳ QDP
                              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primEqNat(Succ(yu3000), Succ(yu40000)) → new_primEqNat(yu3000, yu40000)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
QDP
                                ↳ QDPSizeChangeProof
                              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_esEs1(@2(yu300, yu301), @2(yu4000, yu4001), app(app(app(ty_@3, gf), gg), gh), ge) → new_esEs0(yu300, yu4000, gf, gg, gh)
new_esEs0(@3(yu300, yu301, yu302), @3(yu4000, yu4001, yu4002), bb, app(app(ty_@2, dc), dd), cf) → new_esEs1(yu301, yu4001, dc, dd)
new_esEs(Just(@3(yu300, yu301, yu302)), Just(@3(yu4000, yu4001, yu4002)), app(app(app(ty_@3, app(app(app(ty_@3, ea), eb), ec)), bc), cf)) → new_esEs0(yu300, yu4000, ea, eb, ec)
new_esEs(Just(:(yu300, yu301)), Just(:(yu4000, yu4001)), app(ty_[], app(ty_[], bdc))) → new_esEs3(yu300, yu4000, bdc)
new_esEs(Just(:(yu300, yu301)), Just(:(yu4000, yu4001)), app(ty_[], bcb)) → new_esEs3(yu301, yu4001, bcb)
new_esEs3(:(yu300, yu301), :(yu4000, yu4001), app(ty_[], bdc)) → new_esEs3(yu300, yu4000, bdc)
new_esEs0(@3(yu300, yu301, yu302), @3(yu4000, yu4001, yu4002), app(app(ty_Either, ef), eg), bc, cf) → new_esEs2(yu300, yu4000, ef, eg)
new_esEs1(@2(yu300, yu301), @2(yu4000, yu4001), app(ty_[], he), ge) → new_esEs3(yu300, yu4000, he)
new_esEs(Just(@2(yu300, yu301)), Just(@2(yu4000, yu4001)), app(app(ty_@2, app(app(ty_@2, ha), hb)), ge)) → new_esEs1(yu300, yu4000, ha, hb)
new_esEs(Just(@2(yu300, yu301)), Just(@2(yu4000, yu4001)), app(app(ty_@2, app(ty_Maybe, gd)), ge)) → new_esEs(yu300, yu4000, gd)
new_esEs0(@3(yu300, yu301, yu302), @3(yu4000, yu4001, yu4002), app(ty_[], eh), bc, cf) → new_esEs3(yu300, yu4000, eh)
new_esEs3(:(yu300, yu301), :(yu4000, yu4001), app(app(app(ty_@3, bcd), bce), bcf)) → new_esEs0(yu300, yu4000, bcd, bce, bcf)
new_esEs(Just(@3(yu300, yu301, yu302)), Just(@3(yu4000, yu4001, yu4002)), app(app(app(ty_@3, app(app(ty_Either, ef), eg)), bc), cf)) → new_esEs2(yu300, yu4000, ef, eg)
new_esEs(Just(Right(yu300)), Just(Right(yu4000)), app(app(ty_Either, bah), app(app(ty_@2, bbe), bbf))) → new_esEs1(yu300, yu4000, bbe, bbf)
new_esEs(Just(Left(yu300)), Just(Left(yu4000)), app(app(ty_Either, app(ty_Maybe, hf)), hg)) → new_esEs(yu300, yu4000, hf)
new_esEs(Just(yu30), Just(yu400), app(ty_Maybe, ba)) → new_esEs(yu30, yu400, ba)
new_esEs2(Left(yu300), Left(yu4000), app(app(ty_Either, bae), baf), hg) → new_esEs2(yu300, yu4000, bae, baf)
new_esEs(Just(Right(yu300)), Just(Right(yu4000)), app(app(ty_Either, bah), app(ty_Maybe, bba))) → new_esEs(yu300, yu4000, bba)
new_esEs(Just(@3(yu300, yu301, yu302)), Just(@3(yu4000, yu4001, yu4002)), app(app(app(ty_@3, bb), bc), app(app(ty_Either, cb), cc))) → new_esEs2(yu302, yu4002, cb, cc)
new_esEs(Just(@2(yu300, yu301)), Just(@2(yu4000, yu4001)), app(app(ty_@2, app(app(app(ty_@3, gf), gg), gh)), ge)) → new_esEs0(yu300, yu4000, gf, gg, gh)
new_esEs3(:(yu300, yu301), :(yu4000, yu4001), bcb) → new_esEs3(yu301, yu4001, bcb)
new_esEs2(Left(yu300), Left(yu4000), app(ty_[], bag), hg) → new_esEs3(yu300, yu4000, bag)
new_esEs0(@3(yu300, yu301, yu302), @3(yu4000, yu4001, yu4002), bb, app(ty_[], dg), cf) → new_esEs3(yu301, yu4001, dg)
new_esEs(Just(@2(yu300, yu301)), Just(@2(yu4000, yu4001)), app(app(ty_@2, fa), app(app(ty_@2, fg), fh))) → new_esEs1(yu301, yu4001, fg, fh)
new_esEs1(@2(yu300, yu301), @2(yu4000, yu4001), fa, app(app(ty_@2, fg), fh)) → new_esEs1(yu301, yu4001, fg, fh)
new_esEs(Just(:(yu300, yu301)), Just(:(yu4000, yu4001)), app(ty_[], app(app(ty_@2, bcg), bch))) → new_esEs1(yu300, yu4000, bcg, bch)
new_esEs0(@3(yu300, yu301, yu302), @3(yu4000, yu4001, yu4002), bb, bc, app(app(ty_@2, bh), ca)) → new_esEs1(yu302, yu4002, bh, ca)
new_esEs(Just(@3(yu300, yu301, yu302)), Just(@3(yu4000, yu4001, yu4002)), app(app(app(ty_@3, bb), app(ty_[], dg)), cf)) → new_esEs3(yu301, yu4001, dg)
new_esEs(Just(@2(yu300, yu301)), Just(@2(yu4000, yu4001)), app(app(ty_@2, fa), app(ty_[], gc))) → new_esEs3(yu301, yu4001, gc)
new_esEs(Just(@2(yu300, yu301)), Just(@2(yu4000, yu4001)), app(app(ty_@2, fa), app(app(app(ty_@3, fc), fd), ff))) → new_esEs0(yu301, yu4001, fc, fd, ff)
new_esEs(Just(:(yu300, yu301)), Just(:(yu4000, yu4001)), app(ty_[], app(app(app(ty_@3, bcd), bce), bcf))) → new_esEs0(yu300, yu4000, bcd, bce, bcf)
new_esEs2(Right(yu300), Right(yu4000), bah, app(app(ty_Either, bbg), bbh)) → new_esEs2(yu300, yu4000, bbg, bbh)
new_esEs(Just(@3(yu300, yu301, yu302)), Just(@3(yu4000, yu4001, yu4002)), app(app(app(ty_@3, bb), bc), app(ty_[], cd))) → new_esEs3(yu302, yu4002, cd)
new_esEs(Just(Left(yu300)), Just(Left(yu4000)), app(app(ty_Either, app(ty_[], bag)), hg)) → new_esEs3(yu300, yu4000, bag)
new_esEs1(@2(yu300, yu301), @2(yu4000, yu4001), fa, app(app(ty_Either, ga), gb)) → new_esEs2(yu301, yu4001, ga, gb)
new_esEs3(:(yu300, yu301), :(yu4000, yu4001), app(app(ty_Either, bda), bdb)) → new_esEs2(yu300, yu4000, bda, bdb)
new_esEs2(Right(yu300), Right(yu4000), bah, app(ty_[], bca)) → new_esEs3(yu300, yu4000, bca)
new_esEs1(@2(yu300, yu301), @2(yu4000, yu4001), fa, app(ty_[], gc)) → new_esEs3(yu301, yu4001, gc)
new_esEs0(@3(yu300, yu301, yu302), @3(yu4000, yu4001, yu4002), app(app(ty_@2, ed), ee), bc, cf) → new_esEs1(yu300, yu4000, ed, ee)
new_esEs(Just(@3(yu300, yu301, yu302)), Just(@3(yu4000, yu4001, yu4002)), app(app(app(ty_@3, app(app(ty_@2, ed), ee)), bc), cf)) → new_esEs1(yu300, yu4000, ed, ee)
new_esEs(Just(@3(yu300, yu301, yu302)), Just(@3(yu4000, yu4001, yu4002)), app(app(app(ty_@3, bb), bc), app(ty_Maybe, bd))) → new_esEs(yu302, yu4002, bd)
new_esEs0(@3(yu300, yu301, yu302), @3(yu4000, yu4001, yu4002), bb, app(ty_Maybe, ce), cf) → new_esEs(yu301, yu4001, ce)
new_esEs(Just(@3(yu300, yu301, yu302)), Just(@3(yu4000, yu4001, yu4002)), app(app(app(ty_@3, app(ty_[], eh)), bc), cf)) → new_esEs3(yu300, yu4000, eh)
new_esEs(Just(@3(yu300, yu301, yu302)), Just(@3(yu4000, yu4001, yu4002)), app(app(app(ty_@3, bb), app(app(app(ty_@3, cg), da), db)), cf)) → new_esEs0(yu301, yu4001, cg, da, db)
new_esEs1(@2(yu300, yu301), @2(yu4000, yu4001), fa, app(ty_Maybe, fb)) → new_esEs(yu301, yu4001, fb)
new_esEs0(@3(yu300, yu301, yu302), @3(yu4000, yu4001, yu4002), bb, bc, app(app(ty_Either, cb), cc)) → new_esEs2(yu302, yu4002, cb, cc)
new_esEs(Just(@3(yu300, yu301, yu302)), Just(@3(yu4000, yu4001, yu4002)), app(app(app(ty_@3, bb), bc), app(app(ty_@2, bh), ca))) → new_esEs1(yu302, yu4002, bh, ca)
new_esEs(Just(@2(yu300, yu301)), Just(@2(yu4000, yu4001)), app(app(ty_@2, fa), app(ty_Maybe, fb))) → new_esEs(yu301, yu4001, fb)
new_esEs0(@3(yu300, yu301, yu302), @3(yu4000, yu4001, yu4002), bb, bc, app(ty_Maybe, bd)) → new_esEs(yu302, yu4002, bd)
new_esEs2(Left(yu300), Left(yu4000), app(app(ty_@2, bac), bad), hg) → new_esEs1(yu300, yu4000, bac, bad)
new_esEs2(Left(yu300), Left(yu4000), app(app(app(ty_@3, hh), baa), bab), hg) → new_esEs0(yu300, yu4000, hh, baa, bab)
new_esEs1(@2(yu300, yu301), @2(yu4000, yu4001), app(app(ty_Either, hc), hd), ge) → new_esEs2(yu300, yu4000, hc, hd)
new_esEs0(@3(yu300, yu301, yu302), @3(yu4000, yu4001, yu4002), bb, bc, app(ty_[], cd)) → new_esEs3(yu302, yu4002, cd)
new_esEs(Just(@2(yu300, yu301)), Just(@2(yu4000, yu4001)), app(app(ty_@2, app(ty_[], he)), ge)) → new_esEs3(yu300, yu4000, he)
new_esEs(Just(:(yu300, yu301)), Just(:(yu4000, yu4001)), app(ty_[], app(app(ty_Either, bda), bdb))) → new_esEs2(yu300, yu4000, bda, bdb)
new_esEs2(Right(yu300), Right(yu4000), bah, app(app(app(ty_@3, bbb), bbc), bbd)) → new_esEs0(yu300, yu4000, bbb, bbc, bbd)
new_esEs2(Right(yu300), Right(yu4000), bah, app(app(ty_@2, bbe), bbf)) → new_esEs1(yu300, yu4000, bbe, bbf)
new_esEs(Just(Left(yu300)), Just(Left(yu4000)), app(app(ty_Either, app(app(ty_@2, bac), bad)), hg)) → new_esEs1(yu300, yu4000, bac, bad)
new_esEs0(@3(yu300, yu301, yu302), @3(yu4000, yu4001, yu4002), bb, app(app(app(ty_@3, cg), da), db), cf) → new_esEs0(yu301, yu4001, cg, da, db)
new_esEs(Just(:(yu300, yu301)), Just(:(yu4000, yu4001)), app(ty_[], app(ty_Maybe, bcc))) → new_esEs(yu300, yu4000, bcc)
new_esEs(Just(@2(yu300, yu301)), Just(@2(yu4000, yu4001)), app(app(ty_@2, fa), app(app(ty_Either, ga), gb))) → new_esEs2(yu301, yu4001, ga, gb)
new_esEs(Just(@3(yu300, yu301, yu302)), Just(@3(yu4000, yu4001, yu4002)), app(app(app(ty_@3, bb), app(ty_Maybe, ce)), cf)) → new_esEs(yu301, yu4001, ce)
new_esEs2(Left(yu300), Left(yu4000), app(ty_Maybe, hf), hg) → new_esEs(yu300, yu4000, hf)
new_esEs(Just(@3(yu300, yu301, yu302)), Just(@3(yu4000, yu4001, yu4002)), app(app(app(ty_@3, bb), app(app(ty_@2, dc), dd)), cf)) → new_esEs1(yu301, yu4001, dc, dd)
new_esEs(Just(Left(yu300)), Just(Left(yu4000)), app(app(ty_Either, app(app(ty_Either, bae), baf)), hg)) → new_esEs2(yu300, yu4000, bae, baf)
new_esEs(Just(@3(yu300, yu301, yu302)), Just(@3(yu4000, yu4001, yu4002)), app(app(app(ty_@3, bb), app(app(ty_Either, de), df)), cf)) → new_esEs2(yu301, yu4001, de, df)
new_esEs(Just(Right(yu300)), Just(Right(yu4000)), app(app(ty_Either, bah), app(app(ty_Either, bbg), bbh))) → new_esEs2(yu300, yu4000, bbg, bbh)
new_esEs3(:(yu300, yu301), :(yu4000, yu4001), app(app(ty_@2, bcg), bch)) → new_esEs1(yu300, yu4000, bcg, bch)
new_esEs0(@3(yu300, yu301, yu302), @3(yu4000, yu4001, yu4002), bb, bc, app(app(app(ty_@3, be), bf), bg)) → new_esEs0(yu302, yu4002, be, bf, bg)
new_esEs(Just(Left(yu300)), Just(Left(yu4000)), app(app(ty_Either, app(app(app(ty_@3, hh), baa), bab)), hg)) → new_esEs0(yu300, yu4000, hh, baa, bab)
new_esEs2(Right(yu300), Right(yu4000), bah, app(ty_Maybe, bba)) → new_esEs(yu300, yu4000, bba)
new_esEs1(@2(yu300, yu301), @2(yu4000, yu4001), app(app(ty_@2, ha), hb), ge) → new_esEs1(yu300, yu4000, ha, hb)
new_esEs(Just(@3(yu300, yu301, yu302)), Just(@3(yu4000, yu4001, yu4002)), app(app(app(ty_@3, bb), bc), app(app(app(ty_@3, be), bf), bg))) → new_esEs0(yu302, yu4002, be, bf, bg)
new_esEs(Just(@2(yu300, yu301)), Just(@2(yu4000, yu4001)), app(app(ty_@2, app(app(ty_Either, hc), hd)), ge)) → new_esEs2(yu300, yu4000, hc, hd)
new_esEs1(@2(yu300, yu301), @2(yu4000, yu4001), app(ty_Maybe, gd), ge) → new_esEs(yu300, yu4000, gd)
new_esEs(Just(Right(yu300)), Just(Right(yu4000)), app(app(ty_Either, bah), app(ty_[], bca))) → new_esEs3(yu300, yu4000, bca)
new_esEs(Just(Right(yu300)), Just(Right(yu4000)), app(app(ty_Either, bah), app(app(app(ty_@3, bbb), bbc), bbd))) → new_esEs0(yu300, yu4000, bbb, bbc, bbd)
new_esEs(Just(@3(yu300, yu301, yu302)), Just(@3(yu4000, yu4001, yu4002)), app(app(app(ty_@3, app(ty_Maybe, dh)), bc), cf)) → new_esEs(yu300, yu4000, dh)
new_esEs0(@3(yu300, yu301, yu302), @3(yu4000, yu4001, yu4002), bb, app(app(ty_Either, de), df), cf) → new_esEs2(yu301, yu4001, de, df)
new_esEs3(:(yu300, yu301), :(yu4000, yu4001), app(ty_Maybe, bcc)) → new_esEs(yu300, yu4000, bcc)
new_esEs0(@3(yu300, yu301, yu302), @3(yu4000, yu4001, yu4002), app(ty_Maybe, dh), bc, cf) → new_esEs(yu300, yu4000, dh)
new_esEs0(@3(yu300, yu301, yu302), @3(yu4000, yu4001, yu4002), app(app(app(ty_@3, ea), eb), ec), bc, cf) → new_esEs0(yu300, yu4000, ea, eb, ec)
new_esEs1(@2(yu300, yu301), @2(yu4000, yu4001), fa, app(app(app(ty_@3, fc), fd), ff)) → new_esEs0(yu301, yu4001, fc, fd, ff)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
QDP
                                ↳ QDPSizeChangeProof

Q DP problem:
The TRS P consists of the following rules:

new_foldr(yu3, yu4110, yu4111, yu64, yu65, ba) → new_foldr0(yu3, yu4110, yu4111, new_primPlusNat0(yu64, Zero), new_primPlusNat0(yu64, Zero), ba)
new_foldr0(yu3, yu4110, :(yu41110, yu41111), yu68, yu67, ba) → new_foldr(yu3, yu41110, yu41111, yu67, yu67, ba)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, yu400100) → Succ(yu400100)
new_primPlusNat0(Succ(yu660), yu400100) → Succ(Succ(new_primPlusNat1(yu660, yu400100)))
new_primPlusNat1(Succ(yu6600), Zero) → Succ(yu6600)
new_primPlusNat1(Zero, Succ(yu4001000)) → Succ(yu4001000)
new_primPlusNat1(Succ(yu6600), Succ(yu4001000)) → Succ(Succ(new_primPlusNat1(yu6600, yu4001000)))
new_primPlusNat1(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primPlusNat1(Zero, Succ(x0))
new_primPlusNat0(Zero, x0)
new_primPlusNat1(Succ(x0), Succ(x1))
new_primPlusNat1(Succ(x0), Zero)
new_primPlusNat1(Zero, Zero)
new_primPlusNat0(Succ(x0), x1)

We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs: